﻿#include<iostream>
using namespace std;


//int main() {
//	int year;
//	bool isLeapYear;
//	cout << "Enter the year :" << endl;
//	cin >> year;
//	isLeapYear = ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
//	if (isLeapYear) {
//		cout << year << " is a leap year" << endl;
//	}
//	else {
//		cout << year << "is not a leap year" << endl;
//	}
//	return 0;
//}
//int main(){
//	int i, j;
//	for (i = 0; i < 4; i++) {
//		for (j = 6 - 2*i ; j > 0; j--) {
//			cout << " ";
//		}
//		int k = 0;
//		for (k = 0; k < 2*i + 1; k++) {
//			cout << "*";
//		}
//		cout << endl;
//	}
//	for (i = 4; i < 7; i++) {
//		int k = 13 - 2 * i;
//		for (k = 13 - 2 * i; k > 0; k--) {
//			cout << "*";
//		}
//			for (j = 2 * i - 8; j < 4; j++) {
//			cout << " ";
//		}
//		cout << endl;
//	}
//}//打菱形
//double power(double x, int n) {
//	double val = 1.0;
//	while (n--) {
//		val *= x;
//	}
//	return val;
//}
//int main() {
//	int value = 0;
//	cout << "Enter a 8 bit number: " ;//把八进制数变成十进制数
//	for (int i = 7; i >= 0; i--) {
//		char ch;
//		cin >> ch;
//		if (ch == '1') {
//			value += power(2, i);
//		}
//	}
//	cout << "Decimal value is " << value << endl;
//	return 0;
//}
//#include<cstdlib>
//int rollDice() {
//	int die1 = 1 + rand() % 6;
//	int die2 = 1 + rand() % 6;
//	int sum = die1 + die2;
//	cout << "player rolled " << die1 << "+" << die2 << "=" << sum << endl;
//	return sum;
//}
//enum GameStatus{WIN,LOSE,PLAYING};
//int main() {
//	int sum, myPoint;
//	GameStatus status;
//	unsigned seed;
//	cout << "Please enter an unsinged integer: ";
//	cin >> seed;
//	srand(seed);
//	sum = rollDice();
//	switch (sum) {
//	case 7:
//	case 11:
//		status = WIN;
//		break;
//	case 2:
//	case 3:
//	case 12:
//		status = LOSE;
//		break;
//	default:
//		status = PLAYING;
//		myPoint = sum;
//		cout << "point is " << myPoint << endl;
//		break;
//	}
//	while (status == PLAYING) {
//		sum = rollDice();
//		if (sum == myPoint) {
//			status = WIN;
//		}
//		else if (sum == 7) {
//			status = LOSE;
//		}
//	}
//	if (status == WIN) {
//		cout << "player wins" << endl;
//	}
//	else
//		cout << "player lose" << endl;
//	return 0;
//}
//class Clock {
//public:
// 
//	Clock(int newH, int newM, int newS);//构造函数
//	Clock();//默认构造函数
// 
//	void settime(int newH, int newM, int newS);
//	void showtime();
//private:
//	int hour, minute, second;
//};
//void Clock::settime(int newH, int newM, int newS) {
//	hour = newH;
//	minute = newM;
//	second = newS;
//}
//inline void Clock::showtime() {
//	cout << hour << ":" << minute << ":" << second << endl;
//}
//Clock::Clock(int newH, int newM, int newS):hour(newH),minute(newM),second(newS){
//	cout << "调用构造函数" << endl;
//}
//Clock::Clock():hour(0),minute(0),second(0){
//	cout << "调用默认构造函数" << endl;
//}
//
//int main() {
//	Clock c1(1, 1, 1);
//	Clock c2;
//	cout << "The second time is:" << endl;
//	c1.showtime();
//	c2.showtime();
//	cout << "The first time is:" << endl; 
//	c1.settime(12, 12, 12);
//	c2.settime(12, 12, 12);
//	c1.showtime();
//	c2.showtime();
//	return 0;
//}
//class Point {
//public:
//	Point(int xx = 0, int yy = 0) {
//		x = xx;
//		y = yy;
//	}
//	Point(Point &p);
//	int getx() { return x; }
//	int gety() { return y; }
//private:
//	int x, y;
//};
//Point::Point(Point& p) {
//	x = p.x;
//	y = p.y;
//	cout << "调用复制构造函数" << endl;
//}
//void fun1(Point p) {
//	cout << p.getx() << endl;
//}
//Point fun2() {
//	Point a(1, 2);
//	return a;
//}
//int main() {
//	Point a(4, 5);
//	Point b = a;
//	cout << b.getx() << endl;
//	fun1(b);
//	b=fun2();
//	cout << b.getx() << endl;
//	return 0;
//}
//const float PI = 3.1415926;
//const float	FENCE_PRICE = 35;
//const float CONCRETE_PRICE = 20;
//class Circle {
//public:
//	Circle (float r);
//	float circumference();
//	float area();
//private:
//	float radius;
//};
////传入圆的半径
//Circle::Circle(float r) {
//	radius = r;
//}
////圆的周长
//float Circle::circumference() {
//	return 2 * PI * radius;
//}
////圆的面积
//float Circle::area() {
//	return PI * radius * radius;
//}
//int main() {
//	float radius;
//	cout << "Enter the radius of the pool:";
//	cin >> radius;
//	Circle pool(radius);
//	Circle poolRim(radius + 3);
//
//	//计算栅栏价格
//	float fenceCost = poolRim.circumference() * FENCE_PRICE;
//	cout << "Fencing Cost is $" << fenceCost <<  endl;
//
//	//计算水泥价格
//	float concreteCost = (poolRim.area() - pool.area()) * CONCRETE_PRICE;
//	cout << "ConreteCost is $" << concreteCost << endl;
//	return 0;
//}
//#include<cmath>
//class Point {
//public:
//    Point(int xx = 0, int yy = 0) : x(xx), y(yy) {}
//    Point(const Point& p) : x(p.x), y(p.y) {
//        cout << "调用复制构造函数" << endl;
//    }
//    int getX() const { return x; }
//    int getY() const { return y; }
//private:
//    int x, y;
//};
//class Line {
//public:
//    Line(const Point& xp1, const Point& xp2) : p1(xp1), p2(xp2) {
//        cout << "调用Line函数体" << endl;
//        double x = static_cast<double>(p1.getX() - p2.getX());
//        double y = static_cast<double>(p1.getY() - p2.getY());
//        len = sqrt(x * x + y * y);
//    }
//    Line(const Line& l) : p1(l.p1), p2(l.p2), len(l.len) {
//        cout << "调用Line的复制构造函数" << endl;
//    }
//    double getLen() const { return len; }
//private:
//    Point p1, p2;
//    double len;
//};
//
//int main() {
//	Point myp1(1, 1), myp2(4, 5);
//	Line line(myp1, myp2);
//	Line line2(line);
//	cout << "The length of the line is:" << endl;
//	cout << line.getLen() << endl;
//	cout << "The length of the line2 is:" << endl;
//	cout << line2.getLen() << endl;
//	return 0;
//}

//#include <cstring>
//
//class String {
//private:
//    char* data;
//public:
//    // 默认构造函数
//    String(const char* s = "") {
//        if (s) {
//            data = new char[strlen(s) + 1];
//            strcpy_s(data, s);
//        }
//        else {
//            data = new char[1];
//            *data = '\0';
//        }
//    }
//
//    // 拷贝构造函数
//    String(const String& other) {
//        data = new char[strlen(other.data) + 1];
//        strcpy_s(data, other.data);
//    }
//
//    // 析构函数
//    ~String() {
//        delete[] data;
//    }
//
//    // 赋值运算符重载（字符常量）
//    String& operator=(const char* s) {
//        delete[] data;
//        data = new char[strlen(s) + 1];
//        strcpy_s(data, s);
//        return *this;
//    }
//
//    // 赋值运算符重载（String对象）
//    String& operator=(const String& other) {
//        if (this != &other) {
//            delete[] data;
//            data = new char[strlen(other.data) + 1];
//            strcpy_s(data, other.data);
//        }
//        return *this;
//    }
//
//    // 串连接重载（+）
//    String operator+(const String& other) const {
//        String newString;
//        newString.data = new char[strlen(data) + strlen(other.data) + 1];
//        strcpy_s(newString.data, data);
//        strcat_s(newString.data, other.data);
//        return newString;
//    }
//
//    // 串连接重载（+=）
//    String& operator+=(const String& other) {
//        char* newData = new char[strlen(data) + strlen(other.data) + 1];
//        strcpy_s(newData, data);
//        strcat_s(newData, other.data);
//        delete[] data;
//        data = newData;
//        return *this;
//    }
//
//    // 下标运算符重载
//    char& operator[](int index) {
//        return data[index];
//    }
//
//    // 串比较重载（==）
//    bool operator==(const String& other) const {
//        return strcmp(data, other.data) == 0;
//    }
//
//    // 串比较重载（<）
//    bool operator<(const String& other) const {
//        return strcmp(data, other.data) < 0;
//    }
//
//    // 输入运算符重载
//    friend std::istream& operator>>(std::istream& is, String& str) {
//        char buffer[1000];  // 假设最大长度为1000
//        is >> buffer;
//        str = buffer;
//        return is;
//    }
//
//    // 输出运算符重载
//    friend std::ostream& operator<<(std::ostream& os, const String& str) {
//        os << str.data;
//        return os;
//    }
//};
//
//int main() {
//    String s1("Hello");
//    String s2(" World!");
//    String s3 = s1 + s2;
//    std::cout << "s3: " << s3 << std::endl;
//
//    s3 += s1;
//    std::cout << "s3 after += : " << s3 << std::endl;
//
//    std::cout << "s3[1]: " << s3[1] << std::endl;  // Output 'e'
//
//    String s4;
//    std::cout << "Enter a string: ";
//    std::cin >> s4;
//    std::cout << "You entered: " << s4 << std::endl;
//
//    return 0;
//}
//#include<iostream>
//using namespace std;
//
//class Base {
//public:
//    virtual void Show() { cout << 'B'; }
//};
//
//class Derived : public Base {
//public:
//    void Show() override { cout << 'D'; }  // it's good practice to use 'override' to explicitly state that this is overriding a base class function
//};
//
//int main() {
//    Base* p1 = new Derived;
//    Derived* p2 = new Derived;
//
//    p1->Show();   // Output: D
//    p2->Show();   // Output: D
//
//    delete p1;
//    delete p2;
//
//    return 0;
//}
//#include<iostream>
//
//using namespace std;
//
//class B {
//public:
//    virtual void f() { cout << "B"; }
//    void g() { cout << "B"; }
//};
//
//class D : public B {
//public:
//    void f() override { cout << "D"; }  // Using 'override' keyword to indicate overriding
//    void g() { cout << "D"; }
//};
//
//void h(B* p) {
//    p->f();   // Calls the overridden function in D, which outputs "D"
//    p->g();   // Calls the non-virtual function in B, which outputs "B"
//}
//
//int main() {
//    D obj;
//    h(&obj);  // Should output "DB"
//
//    return 0;
//}
//class CD {
//public:
//	~CD();
//private:
//	char name[80];
//};
//CD::~CD() {
//	cout << "A";
//}
//int main() {
//	CD a, * b, d[4];
//	return 0;
//}

//#include <iostream>
//
//// Assuming you want to use members of the std namespace without prefixing them with "std::"
//using namespace std;
//
//class Base {
//public:
//    // Constructor initializes x and outputs its value
//    Base(int n = 0) : x(n) { cout << n; }
//
//    int getX() const { return x; }
//
//private:
//    int x;
//};
//
//class Derived : public Base {
//public:
//    // Initialization list correctly calls Base constructor and initializes y
//    Derived(int m, int n) : Base(n), y(m) { cout << m; }
//
//    // Calls Base's default constructor implicitly
//    Derived(int m) : y(m) { cout << m; }
//
//private:
//    int y;
//};
//
//int main() {
//    Derived d1(5), d2(4, 9); // Should print "59" -- 5 from d1 then 9 and 4 from d2
//    return 0;
//}
//double Div(double x, double y) {
//	if (y == 0)
//		throw y;
//	else
//		return x + y;
//}
//int main() {
//	try {
//		cout << Div(5, 2);
//		cout << Div(5, 0);
//		cout << Div(5, 2);
//	}
//	catch (double) {
//		cout << "expect of deviding zero.";
//	}
//	cout << "that is ok";
//	return 0;
//}
//class A {
//	int x;
//public:
//	A(int a) { x = a; }
//	virtual void Show() {
//		cout << x;
//	}
//};
//class B :public A {
//	int y;
//public:
//	B(int a, int b) {
//		y = b;
//	}
//	void Show() {
//		A::Show();
//		cout << y;
//	}
//};
//void Show(A& pa) {
//	pa.Show();
//}
//int main() {
//	A a; B b(2, 3);
//	Show(&a);
//	Show(&b);
//}
//#include <iostream>
//#define PI 3.14
//using namespace std;
//class Shape {
//public:
//    virtual double GetArea() const = 0;
//    virtual ~Shape() {}
//};
//class Rectangle : public Shape {
//private:
//    double width;
//    double height;
//public:
//    Rectangle(double w, double h) : width(w), height(h) {}
//    double GetArea() const override{
//        return width * height;
//}
//};
//class Circle : public Shape {
//private:
//    double radius;
//public:
//    Circle(double r) : radius(r) {}
//
//    double GetArea() const override {
//        return PI * radius * radius;
//    }
//};
//
//int main() {
//    double width, height, radius;
//    cin >> width;
//    cin >> height;
//    cin >> radius;
//    Rectangle rect(width, height);
//    Circle circ(radius);
//
//    cout << "三角形的面积为: " << rect.GetArea() << endl;
//    cout << "圆的面积为: " << circ.GetArea() << endl;
//
//    return 0;
//}
//class Base {
//protected:
//	int x;
//public:
//	Base() { x = 0; };
//	Base(int xx) { x = xx; };
//	void operator++() { x = x + 1; };
//	void operator++(int) { x = x + 1; };
//};
//class Derived :public Base {
//	int y;
//public:
//	Derived() { y = 0; };
//	Derived(int x1, int x2) :Base(x2) { y = x1; };
//	void operator--() { x = x - 1; y = y - 1; };
//	void operator--(int) { x = x - 2; y = y - 2; };
//	void disp() { cout << x << y; }
//};
//int main() {
//	Derived d(8, 9);
//	d++;
//	d.disp();
//	--d;
//	d.disp();
//	return 0;
//}
//#include <iostream>
//#define PI 3.14
//using namespace std;
//class Shape {
//public:
//    virtual double GetArea() const = 0;
//    virtual ~Shape() {}
//};
//class Rectangle : public Shape {
//private:
//    double width;
//    double height;
//public:
//    Rectangle(double w = 30, double h = 20) : width(w), height(h) {}
//    double GetArea() const override {
//        return width * height;
//    }
//};
//class Circle : public Shape {
//private:
//    double radius;
//public:
//    Circle(double r = 20) : radius(r) {}
//
//    double GetArea() const override {
//        return PI * radius * radius;
//    }
//};
//int main()
//{
//    Rectangle a(4, 5), b;
//    Circle c(10), d;
//    Shape* p[4] = { &a,&b,&c,&d };
//    for (int i = 0; i < 4; i++)
//        cout << p[i]->GetArea() << endl;
//    return 0;
//}
//class Point {
//public:
//	Point(int x = 0, int y = 0) :x(x), y(y) {
//		count++;
//	}
//	Point(Point& p) {
//		x = p.x;
//		y = p.y;
//		count++;
//	}
//	~Point() { count--; }
//	int getX() { return x; }
//	int getY() { return y; }
//
//	void showcount() {
//		cout << "Object count=" << count << endl;
//	}
//private:
//	int x, y;
//	static int count;
//};
//int Point::count = 0;
//int main() {
//	Point a(4, 5);
//	cout << "Point A:" << a.getX() << "," << a.getY();
//	a.showcount();
//
//	Point b(a);
//	cout << "Point B:" << b.getX() << "," << b.getY();
//	b.showcount();
//	return 0;
//}
//#include<cmath>
//class Point {
//public:
//	Point(int x=0,int y=0):x(x),y(y){}
//	int getx() { return x; }
//	int gety() { return y; }
//	friend float dist(Point& p1, Point& p2);
//private:
//	int x, y;
//};
//float dist(Point& p1, Point& p2) {
//	double x = p1.x - p2.x;
//	double y = p1.y - p2.y;
//	return sqrt(x * x + y * y);
//}
//int main() {
//	Point myp1(1, 1), myp2(4, 5);
//	cout << "the distance is :";
//	cout << dist(myp1, myp2) << endl;
//	return 0;
//}
//class R {
//public:
//	R(int r1,int r2):r1(r1),r2(r2){}
//	void print();
//	void print() const;
//private:
//	int r1, r2;
//};
//void R::print() {
//	cout << r1 << "," << r2 << endl;
//}
//void R::print() const {
//	cout << r1 << ":" << r2 << endl;
//}
//int main() {
//	R a(4, 5);
//	a.print();
//	const R b(20, 52);
//	b.print();
//	return 0;
//}
//#include<iterator>
//int find(int* x, int* y, int arr[]) {
//	while (x != y && *x >= 0) {
//		++x;
//	}
//	const int ret = *x;
//	return ret;
//}
//int main() {
//	int arr[10] = { 1,2,3,-1,-2,6,7,8,9,0 };
//	int* x = begin(arr);
//	int* y = end(arr);
//	cout << "第一个负数为:" << find(x, y, arr) << endl;
//}
//void split(float x, int* intpart, float* frac) {
//	*intpart = (int)x;
//	*frac = x - *intpart;
//}
//int main() {
//	cout << "Enter 3 float point numbers:" << endl;
//	for (int i = 0; i < 3; i++) {
//		float x, f;
//		int n;
//		cin >> x;
//		split(x, &n, &f);
//		cout << "Intpart:" << n << "Fracepart:" << f << endl;
//	}
//}
//#include<iostream>
//using namespace std;
//
//class Circle {
//public:
//    Circle();
//    Circle(double r):radius(r){}
//    void Set(double r);
//    double Get() { return radius; }
//    double Circumference();
//    double Square();
//private:
//    double radius;
//};
//Circle::Circle():radius(10){}
//void Circle::Set(double r) {
//    radius = r;
//}
//double Circle::Circumference() {
//    return 2 * 3.14 * radius;
//}
//double Circle::Square() {
//    return 3.14 * radius * radius;
//}
//
//int main()
//{
//    Circle c1;
//    cout << "Show object c1:" << endl;
//    cout << "    radius=" << c1.Get() << endl;
//    cout << "    Circumference=" << c1.Circumference() << endl;
//    cout << "    Square=" << c1.Square() << endl;
//    double r;
//    cin >> r;
//    Circle c2(r);
//    cout << "Show object c2:" << endl;
//    cout << "    radius=" << c2.Get() << endl;
//    cout << "    Circumference=" << c2.Circumference() << endl;
//    cout << "    Square=" << c2.Square() << endl;
//    cin >> r;
//    cout << "Reset and Show object c1:" << endl;
//    c1.Set(r);
//    cout << "    radius=" << c1.Get() << endl;
//    cout << "    Circumference=" << c1.Circumference() << endl;
//    cout << "    Square=" << c1.Square() << endl;
//    return 0;
//}
//#include<iostream>
//using namespace std;
//
//class Complex {
//public:
//    Complex();
//    Complex(double real,double imag):Real(real),Imag(imag){}
//    void Show();
//    void Set(double real, double imag);
//private:
//    double Real, Imag;
//};
//Complex::Complex():Real(1),Imag(2){}
//void Complex::Set(double real, double imag) {
//    Real = real;
//    Imag = imag;
//}
//void Complex::Show() {
//    if (Real != 0 && Imag > 0) {
//        cout << Real << "+" << Imag << "i" << endl;
//    }
//    if (Real != 0 && Imag < 0) {
//        cout << Real << Imag << "i" << endl;
//    }
//    if (Real == 0 && Imag != 0) {
//        cout << Imag << "i" << endl;
//    }
//    if (Real != 0 && Imag == 0) {
//        cout << Real << endl;
//    }
//    if (Real == 0 && Imag == 0) {
//        cout << "0" << endl;
//    }
//}
//
//int main()
//{
//    Complex c1;
//    cout << "Show object c1:";
//    c1.Show();//1+2i
//    double real, imag;
//    cin >> real >> imag;
//    Complex c2(real, imag);
//    cout << "Show object c2:";
//    c2.Show();
//    cin >> real >> imag;
//    cout << "Reset and Show object c1:";
//    c1.Set(real, imag);
//    c1.Show();
//    return 0;
//}
//#include<iostream>
//#include<iomanip>
//using namespace std;
//
//class Fixed_Deposit {
//private:
//    double Amount;
//    double Rate;
//    int Year;
//public:
//    Fixed_Deposit():Amount(10000),Rate(0.033),Year(1){}
//    Fixed_Deposit(double amount,double rate,int year):Amount(amount),Rate(rate),Year(year){}
//    double GetAmount() { return Amount; }
//    double GetRate() { return Rate; }
//    int GetYears() { return Year; }
//    double GetAll() { return Amount + Amount * Rate * Year; }
//    void Set(double amount, double rate, int year) {
//        Amount = amount;
//        Rate = rate;
//        Year = year;
//    }
//    void Show() {
//        cout << "amount=" << Amount << "  rate=" << Rate * 100 << "%" << "  years=" << Year << "  total=" << Amount + Amount * Rate * Year << endl;
//    }
//};
//
//int main()
//{
//    cout << fixed << setprecision(2);
//    Fixed_Deposit f1;
//    cout << "Show object f1:" << endl;
//    cout << "amount=" << f1.GetAmount();        //输出存款本金
//    cout << "  rate=" << f1.GetRate() * 100 << "%"; //输出存款利率
//    cout << "  years=" << f1.GetYears();        //输出存款年数
//    cout << "  total=" << f1.GetAll() << endl;    //输出到期本息合计
//    double amount, rate;
//    int years;
//    cin >> amount >> rate >> years;
//    Fixed_Deposit f2(amount, rate, years);
//    cout << "Show object f2:" << endl;
//    cout << "amount=" << f2.GetAmount();        //输出存款本金
//    cout << "  rate=" << f2.GetRate() * 100 << "%"; //输出存款利率
//    cout << "  years=" << f2.GetYears();        //输出存款年数
//    cout << "  total=" << f2.GetAll() << endl;    //输出到期本息合计
//    cin >> amount >> rate >> years;
//    cout << "Reset and Show object f1:" << endl;
//    f1.Set(amount, rate, years);
//    f1.Show();
//    return 0;
//}

//class Point {
//public:
//	Point(int xx,int yy):x(xx),y(yy){}
//	Point() :x(1), y(1){}
//	int getX() { return x; }
//	int getY() { return y; }
//private:
//	int x, y;
//};
//int main() {
//	Point a(4, 5);
//	Point b;       
//	Point* p1 = &a;
//	cout << p1->getX() << endl;
//	cout << a.getX() << endl;
//	cout << b.getX() << endl;
//	return 0;
//}

//class Point {
//public:
//	Point(int x=0,int y=0):x(x),y(y){
//		count++;
//	}
//	Point(const Point& p) :x(p.x), y(p.y) {
//		count++;
//	}
//	~Point() { count--; }
//	int getX() { return x; }
//	int getY() { return y; }
//	static int count;//通过指针ptr访问静态数据
//private:
//	int x, y;
//};
//int Point::count = 0;//静态数据初始化
//int main() {
//	int* ptr = &Point::count;
//	Point a(4, 5);
//	cout << "Point A :" << a.getX() << "," << a.getY() << endl;
//	cout << "Object count =" << *ptr << endl;
//	Point b(a);
//	cout << "Point B :" << b.getX() << "," << b.getY() << endl;
//	cout << "Object count =" << *ptr << endl;
//	return 0;
//}

//#include<vector>
//double average(const vector<double>& arr) {
//	double sum = 0;
//	for (unsigned i = 0; i < arr.size(); i++) {
//		sum += arr[i];
//	}
//	return sum / arr.size();
//}
//int main() {
//	unsigned n;
//	cout << "n = ";
//	cin >> n;
//	vector<double>arr(n);
//	cout << "Please input " << n << " real numbers: " << endl;
//	for (unsigned i = 0; i < n; i++) {
//		cin >> arr[i];
//	}
//	cout << "Average = " << average(arr) << endl;
//	return 0;
//}
//#include<string>
//inline void test(const char* title, bool value) {
//	cout << title << "returns " << (value ? "true" : "false") << endl;
//}
//
//int main() {
//	string s1 = "DEF";
//	cout << "s1 is " << s1 << endl;
//	
//	string s2;
//	cout << "Please enter s2 :";
//	getline(cin, s2);//采用getline可以控制输入
//	cout << "length of s2 :" << s2.length() << endl;
//
//	test("s1<=\"ABC\"", s1 <= "ABC");
//	test("\"DEF\"<=s1", "DEF"<=s1);
//		s2 += s1;
//	cout << "s2=s2+s1:" << s2 << endl;
//	cout << "legth of s2 is:" << s2 << endl;
//	return 0;
//}
//#include<string>
//int main() {
//	for (int i = 0; i < 2; i++) {
//		string city, state;
//		getline(cin, city, ',');
//		getline(cin, state);
//		cout << "City: " << city << "  State:" << state << endl;
//	}
//	return 0;
//}
//#include<iostream>
//using namespace std;
//
//class Point {
//public:
//    void Show() { cout << "(" << x << "," << y << ")" << endl; cout << "Function #3 is called!" << endl; }
//    Point(Point& p) {
//        x = p.x;
//        y = p.y;
//        cout << "Function #0 is called!" << endl;
//    }
//    Point():x(19),y(210){
//        cout << "Function #1 is called!" << endl;
//    }
//    Point(int x, int y) :x(x), y(y) {
//        cout << "Function #2 is called!" << endl;
//    }
//private:
//    int x, y;
//};
//class Circle :public Point {
//private:
//    int radius;
//public:
//    Circle(int x, int y) :Point(x,y) ,radius(777){
//        cout << "Function #5 is called!" << endl;
//    }
//    Circle() :radius(135) {
//        cout << "Function #4 is called!" << endl;
//    }
//    Circle(int x, int y, int r) :Point(x, y), radius(r) {
//        cout << "Function #6 is called!" << endl;
//    }
//    Circle(Point& p, int r) :Point(p), radius(r) {
//        cout << "Function #7 is called!" << endl;
//    }
//    Circle(Point& p) :Point(p), radius(111) {
//        cout << "Function #8 is called!" << endl;
//    }
//    Circle(int r) :Point(5, 20), radius(r) {
//        cout << "Function #9 is called!" << endl;
//    }
//    void Show() {
//        cout << "Radius=" << radius << "," << "Center=";
//        Point::Show();
//        cout << "Function #10 is called!" << endl;
//    }
//};
//
//int main()
//{
//    int x, y, r;
//    cin >> x >> y >> r;
//    Point p0;
//    cout << "[Point #0] "; p0.Show();
//    Circle c0;
//    cout << "[Circle #0]";  c0.Show();
//    Circle c1(x, y);
//    cout << "[Circle #1]";  c1.Show();
//    Circle c2(x, y, r);
//    cout << "[Circle #2]";  c2.Show();
//    Circle c3(p0, r);
//    cout << "[Circle #3]";  c3.Show();
//    Circle c4(p0);
//    cout << "[Circle #4]";  c4.Show();
//    Circle c5(r);
//    cout << "[Circle #5]";  c5.Show();
//    return 0;
//}
//#include<iostream>
//using namespace std;
//
//class Point {
//protected:
//    int x, y;
//public:
//    Point():x(0),y(0){
//        cout << "Function #1 is called!" << endl;
//    }
//    Point(int x, int y) :x(x), y(y) {
//        cout << "Function #2 is called!" << endl;
//    }
//    void Show() {
//        cout << "Function #3 is called!" << endl;
//    }
//};
//class Three_dimensional :public Point {
//private:
//    int z;
//public:
//    Three_dimensional() :Point(), z(0) {
//        cout << "Function #4 is called!" << endl;
//    }
//    Three_dimensional(int x, int y, int z) :Point(x, y), z(z) {
//        cout << "Function #5 is called!" << endl;
//    }
//    Three_dimensional(Point& p, int z) :Point(p), z(z) {
//        cout << "Function #6 is called!" << endl;
//    }
//    Three_dimensional(int z) :Point(100, 210), z(z) {
//        cout << "Function #7 is called!" << endl;
//    }
//    Three_dimensional(Point& p) :Point(p), z(11) {
//        cout << "Function #8 is called!" << endl;
//    }
//    void Show() {
//        cout << "(" << x << "," << y << "," << z << ")" << endl;
//        cout << "Function #9 is called!" << endl;
//    }
//};
//
//int main()
//{
//    int x, y, z;
//    cin >> x >> y >> z;
//
//    Point p0;
//    cout << "Point #0: "; p0.Show();
//    Point p1(x, y);
//    cout << "Point 1: "; p1.Show();
//
//    Three_dimensional t0;
//    cout << "Three_dimensional #0: ";  t0.Show();
//    Three_dimensional t1(x, y, z);
//    cout << "Three_dimensional #1: ";  t1.Show();
//    Three_dimensional t2(p1, z);
//    cout << "Three_dimensional #2: ";  t2.Show();
//    Three_dimensional t3(z);
//    cout << "Three_dimensional #3: ";  t3.Show();
//    Three_dimensional t4(p1);
//    cout << "Three_dimensional #4: ";  t4.Show();
//
//    return 0;
//}
//class Base0 {
//public:
//	int var0;
//	void fun0() { cout << "Member of Base0" << endl; }
//};
//class Base1 :virtual public Base0 {
//public:
//	int var1;
//};
//class Base2 :virtual public Base0 {
//public:
//	int var2;
//};
//class Derived :public Base1, public Base2 {
//public:
//	int var;
//	void fun() { cout << "Member of Derived" << endl; }
//};
//int main() {
//	Derived d;
//	d.var0 = 2;
//	d.fun0();
//	return 0;
//}
//class Complex {
//public:
//	Complex(double r=0.0,double i=0.0):real(r),imag(i){}
//	Complex operator+(const Complex& c2) const;
//	Complex operator-(const Complex& c2) const;
//	void display()const;
//private:
//	double real, imag;
//};
//Complex Complex::operator+(const Complex& c2) const {
//	return Complex(real + c2.real, imag + c2.imag);
//}
//Complex Complex::operator-(const Complex& c2) const {
//	return Complex(real - c2.real, imag - c2.imag);
//}
//void Complex::display() const {
//	cout << "(" << real << "," << imag << ")" << endl;
//}
//int main() {
//	Complex c1(4, 5), c2(2, 10), c3;
//	cout << "c1="; c1.display();
//	cout << "c2="; c2.display();
//	c3 = c1 - c2;
//	cout << "c3="; c3.display();
//	c3 = c1 + c2;
//	cout << "c3="; c3.display();
//	return 0;
//}
//class Clock {
//public:
//	Clock(int hour = 0, int minute = 0, int second = 0);
//	void showTime() const;
//	Clock& operator++();
//	Clock operator++(int);
//private:
//	int hour, minute, second;
//};
//Clock::Clock(int hour, int minute, int second) {
//	if (0 <= hour && hour < 24 && 0 <= minute && minute < 60 && 0 <= second && second < 60) {
//		this->hour = hour;
//		this->minute = minute;
//		this->second = second;
//	}
//	else {
//		cout << "Time erro!" << endl;
//	}
//}
//void Clock::showTime() const {
//	cout << hour << ":" << minute << ":" << second << endl;
//}
//Clock& Clock::operator++() {
//	second++;
//	if (second >= 60) {
//		second -= 60;
//		minute++;
//		if (minute >= 60) {
//			minute -= 60;
//			hour = (hour + 1) % 24;
//		}
//	}
//	return *this;
//}
//Clock Clock::operator++(int) {
//	Clock old = *this;
//	++(*this);
//	return old;
//}
//int main() {
//	Clock myclock(23, 59, 59);
//	cout << "First time output: ";
//	myclock.showTime();
//	cout << "Show myclock++: ";
//	(myclock++).showTime();
//	cout << "Show ++myclock: ";
//	(++myclock).showTime();
//	return 0;
//}
//class Complex {
//public:
//	Complex(double r=0.0,double i=0.0):real(r),imag(i){}
//	friend Complex operator+(const Complex& c1, const Complex& c2);
//	friend Complex operator-(const Complex& c1, const Complex& c2);
//	friend ostream& operator<<(ostream& out, const Complex& c);
//private:
//	double real, imag;
//};
//Complex operator+(const Complex& c1, const Complex& c2) {
//	return Complex(c1.real + c2.real, c1.imag + c2.imag);
//}
//Complex operator-(const Complex& c1, const Complex& c2) {
//	return Complex(c1.real - c2.real, c1.imag - c2.imag);
//}
//ostream& operator<<(ostream& out, const Complex& c) {
//	out << "(" << c.real << "," << c.imag << ")";
//	return out;
//}
//int main() {
//	Complex c1(5, 4), c2(2, 10), c3;
//	cout << "c1= " << c1 << endl;
//	cout << "c2= " << c2 << endl;
//	c3 = c1 - c2;
//	cout << "c3= " << c3 << endl;
//	c3 = c1 + c2;
//	cout << "c3= " << c3 << endl;
//	return 0;
//}
//class Base1 {
//public:
//	void display() const;
//};
//void Base1::display() const {
//	cout << "Base1::display()" << endl;
//}
//class Base2 :public Base1 {
//public:
//	void display() const;
//};
//void Base2::display() const {
//	cout << "Base2::display()" << endl;
//}
//class Derived :public Base2 {
//public:
//	void display() const;
//};
//void Derived::display() const {
//	cout << "Derived::display()" << endl;
//}
//void fun(Base1* ptr) {
//	ptr->display();
//}
//int main() {
//	Base1 base1;
//	Base2 base2;
//	Derived derived;
//	fun(&base1);
//	fun(&base2);
//	fun(&derived);
//	return 0;
//}
//template<typename T>
//T abs(T x) {
//	return x < 0 ? -x : x;
//}
//int main() {
//	int n = -5;
//	double d = -5.5;
//	cout << abs(n) << endl;
//	cout << abs(d) << endl;
//	return 0;
//}
//template<class T>
//void outputArray(const T* array, int count) {
//	for (int i = 0; i < count; i++) {
//		cout << array[i] << " ";
//	}
//	cout << endl;
//}
//int main() {
//	const int count1 = 8, count2 = 8, count3 = 20;
//	int a[count1] = { 1,2,3,4,5,6,7,8 };
//	double b[count2] = { 1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8 };
//	char c[count3] = "Welcome to see you!";
//	cout << "a array contains:" << endl;
//	outputArray(a, count1);
//	cout << "b array contains:" << endl;
//	outputArray(b, count2);
//	cout << "c array contains:" << endl;
//	outputArray(c, count3);
//}
//void fun(int& a, int b) {
//	a++;
//	b++;
//}
//int main() {
//	int x = 0, y = 1;
//	fun(x, y);
//	cout << x << "," << y << endl;
//}
//class A {
//public:
//	virtual void f() { cout << "A"; }
//};
//class B :public A{
//public:
//	void f() { cout << "B"; }
//};
//class D :public B {
//public:
//	void f() { cout << "D"; }
//};
//int main() {
//	A a, * p;
//	B b;
//	D d;
//	p = &a;
//	p->f();
//	p = &b;
//	p->f();
//	p = &d;
//	p->f();
//	return 0;
//}
//class A {
//	int a;
//public:
//	~A() { cout << a; }
//	A(int aa = 0) { a = aa; cout << "1"; }
//};
//class B :public A {
//	int b;
//public:
//	~B() { cout << b; }
//	B(int aa = 0, int bb = 0):A(aa) { b = bb; cout << "2"; }
//};
//int main() {
//	B x(3), y(4, 5);
//	return 0;
//}
//class B1 {
//public:
//	B1(int i) { cout << "a" << i; }
//	~B1() { cout << "a"; }
//};
//class B2 {
//public:
//	B2(int j) { cout << "b" << j; }
//	~B2() { cout << "b"; }
//};
//class B3 {
//public:
//	B3() { cout << "c"; }
//	~B3() { cout << "c"; }
//};
//class C :public B2, public B1, public B3 {
//public:
//	C(int a,int b,int c,int d):B2(a),B1(b),mB1(c),mB2(d){}
//private:
//	B1 mB1;
//	B2 mB2;
//	B3 mB3;
//};
//int main() {
//	C obj(0, 1, 2, 3);
//}
//int main() {
//	try {
//		int a = 9;
//		double b = 9.8;
//		throw a < b ? a : b;
//	}
//	catch (int x) { cout << "int " << x << endl; }
//	catch (double y) { cout << "double " << y << endl; }
//}
//class Part {
//	int val;
//public:
//	Part(int x = 0) { val = x; cout << val; }
//	~Part() { cout << val; }
//};
//class Whole {
//	int val;
//	Part p1, p2;
//public:
//	Whole(int x, int y, int z) :p2(x), p1(y), val(z) { cout << val; }
//	~Whole() { cout << val; }
//};
//int main() {
//	Whole obj(1, 2, 3);
//}
//class XX {
//protected:
//	int k;
//public:
//	XX(int n = 1) { k = n; }
//	virtual ~XX() { cout << "X"; }
//	virtual void f() { cout << k - 3; }
//};
//class YY :public XX {
//public:
//	~YY() { cout << "Y"; }
//	void f() { cout << k + 3; XX::f(); }
//};
//int main() {
//	XX& p = *new YY;
//	p.f();
//	delete& p;
//	return 0;
//}
//class excp {
//	char* pstr;
//public:
//	excp(char* m) { pstr = m; }
//	void print() { cerr << pstr << endl; }
//};
//void fun1() { excp a("e"); throw a; }
//void fun2() { try { fun1(); } catch (...) { cerr << "f"; throw; } }
//int main() {
//	try { fun2(); } catch(...) {cerr<<"m"; }
//	return 0;
//
//}
//int fun(int x,int y) { return x * y; }
//template<class T>
//T fun(T a, T b) { return a + b; }
//int main() {
//	cout << fun(1, 2) << fun<int>(2, 3) << fun<double>(3.5, 4.6) << fun<int>(3.5, 4.6) << endl;
//}
//class A {
//	int x;
//public:
//	A(int a) { x = a; }
//	virtual void Show() const { cout << x; }
//};
//class B :public A {
//	int y;
//public:
//	B(int a, int b) :A(a) { y = b; }
//	void Show() { A::Show(); cout << y; }
//};
//class C :public B {
//	int z;
//public:
//	C(int a,int b,int c) :B(a, b) { z = c; }
//	void Show() { B::Show(); cout << z; }
//};
//void Show(A* pa) { pa->Show(); }
//int main() {
//	A a(1);
//	B b(2, 3);
//	C c(4, 5, 6);
//	Show(&a);
//	Show(&b);
//	Show(&c);
//}
//class Base {
//public:
//	Base() {
//		cout << "1" << endl;
//		try {
//			throw "2";
//		}
//		catch (char) { cout << "3" << endl; }
//		catch (char*) { cout << "4" << endl; }
//		throw "5";
//	}
//	~Base() { cout << "6"; }
//};
//void fun(Base t) { cout << "7"; }
//int main() {
//	try { Base t; fun(t); }
//	catch (char*) { cout << "8" << endl; }
//	catch (char) { cout << "9" << endl; }
//	return 0;
//}
//class Base {
//public:
//	~Base() { cout << "1"; }
//};
//char fun() { Base b; throw('2'); return '3'; }
//int main() {
//	try { cout << fun(); }
//	catch (char c) { cout << c; }
//}
//class Base {
//public:
//	Base() { cout << "Base"; }
//};
//class Derived :public Base {
//	int k;
//public:
//	Derived() :k(0) { cout << "Derived"; }
//	Derived(int n) :k(n) { cout << k; }
//};
//int main() {
//	Derived b(4), c;
//}
//int main() {
//	for (int i = 0; i <= 5; i++) {
//		try {
//			if (i == 1) throw '0';
//			if (i == 3) throw "0";
//			if (i == 5) throw 0;
//		}
//		catch (int) { cout << 7; }
//		catch (char*) { cout << 8; }
//		catch (...) { cout << 9; }
//	}
//}
//void fun(int x) {
//	for (int i = 1; i <= x; i++) {
//		try {
//			if (i == 2) throw 'i';
//			if (i == 3) throw i;
//		}
//		catch (int) { cout << "1"; }
//		cout << "2";
//	}
//}
//int main() {
//	try { fun(2); fun(3); }
//	catch (char) { cout << "3"; }
//}
